package service

import (
	"context"
	"fmt"
	"io"
	"time"
)

var ProductService = &productService{}

type productService struct {
	UnimplementedProdServiceServer
}

func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductResponse, error) {
	// 实现具体的业务逻辑
	stock := p.GetStock(request.ProdId)
	return &ProductResponse{
		ProdStock: stock,
	}, nil
}

func (p *productService) GetStock(id int32) int32 {
	return id
}

// UpdateProductStockClientStream 实现客户端流的方法
func (p *productService) UpdateProductStockClientStream(stream ProdService_UpdateProductStockClientStreamServer) error {
	count := 0
	for {
		// 源源不断从客户端接收信息
		resc, err := stream.Recv()
		if err != nil {
			if err == io.EOF { // 这个状态表示接收完成
				fmt.Println("接收完成")
				return nil
			}
			return err
		}
		fmt.Println("服务端接收到的流", resc.ProdId)
		count++
		if count > 10 {
			fmt.Println("接收完成")
			rsp := &ProductResponse{ProdStock: resc.ProdId}
			err := stream.SendAndClose(rsp)
			if err != nil {
				return err
			}
			return nil
		}
	}
}

// GetProductStockServerStream 实现服务端流的方法
func (p *productService) GetProductStockServerStream(req *ProductRequest, stream ProdService_GetProductStockServerStreamServer) error {
	//
	count := 0
	for {
		rsp := &ProductResponse{ProdStock: req.ProdId}
		err := stream.Send(rsp)
		if err != nil {
			fmt.Println("错误", err)
			return err
		}
		time.Sleep(time.Second)
		count++
		fmt.Println("设定发送10次请求就结束了")
		if count > 10 {
			fmt.Println("发送完成")
			return nil
		}
	}
}

// SayHelloStream 双向流实现的方法
func (p *productService) SayHelloStream(stream ProdService_SayHelloStreamServer) error {
	// 这里服务端实现收消息
	for {
		recv, err := stream.Recv()
		if err != nil {
			return nil
		}
		// 服务端收到客户端消息,返回响应
		fmt.Println("服务端收到客户端消息,返回响应", recv.ProdId)
		time.Sleep(time.Second)
		rsp := &ProductResponse{
			ProdStock: recv.ProdId,
		}
		// 服务端收消息的时候也可以不断的发消息
		err = stream.Send(rsp)
		if err != nil {
			fmt.Println(err)
			return err
		}
	}
}
